ટાઇપસ્ક્રિપ્ટ એડવાન્સ્ડ ટાઇપ્સ: ટેમ્પ્લેટ લિટરલ અને કન્ડિશનલ ટાઇપ્સમાં નિપુણતા

આંતરરાષ્ટ્રીય ઉદાહરણ: વિવિધ ડેટ ફોર્મેટ્સ હેન્ડલ કરવા

વિશ્વના વિવિધ પ્રદેશો વિવિધ ડેટ ફોર્મેટ્સનો ઉપયોગ કરે છે. તમે આ વિવિધતાઓને હેન્ડલ કરવા માટે કન્ડિશનલ ટાઇપ્સનો ઉપયોગ કરી શકો છો.

type DateFormat = "YYYY-MM-DD" | "MM/DD/YYYY" | "DD.MM.YYYY";

type ParseDate = T extends "YYYY-MM-DD"
  ? { year: number; month: number; day: number; format: "YYYY-MM-DD" }
  : T extends "MM/DD/YYYY"
  ? { month: number; day: number; year: number; format: "MM/DD/YYYY" }
  : T extends "DD.MM.YYYY"
  ? { day: number; month: number; year: number; format: "DD.MM.YYYY" }
  : never;


function parseDate(dateString: string, format: T): ParseDate {
  // (Implementation would handle different date formats)
  if (format === "YYYY-MM-DD") {
    const [year, month, day] = dateString.split("-").map(Number);
    return { year, month, day, format } as ParseDate;
  } else if (format === "MM/DD/YYYY") {
    const [month, day, year] = dateString.split("/").map(Number);
    return { month, day, year, format } as ParseDate;
  } else if (format === "DD.MM.YYYY") {
    const [day, month, year] = dateString.split(".").map(Number);
    return { day, month, year, format } as ParseDate;
  } else {
    throw new Error("Invalid date format");
  }
}

const parsedDateISO = parseDate("2023-10-27", "YYYY-MM-DD"); // Type: { year: number; month: number; day: number; format: "YYYY-MM-DD"; }
const parsedDateUS = parseDate("10/27/2023", "MM/DD/YYYY"); // Type: { month: number; day: number; year: number; format: "MM/DD/YYYY"; }
const parsedDateEU = parseDate("27.10.2023", "DD.MM.YYYY"); // Type: { day: number; month: number; year: number; format: "DD.MM.YYYY"; }


console.log(parsedDateISO.year); // Access the year knowing it will be there

આ ઉદાહરણ ઉલ્લેખિત ડેટ ફોર્મેટના આધારે વિવિધ ડેટ પાર્સિંગ ફંક્શન્સને વ્યાખ્યાયિત કરવા માટે કન્ડિશનલ ટાઇપ્સનો ઉપયોગ કરે છે. ParseDate ટાઇપ સુનિશ્ચિત કરે છે કે પરત આવેલ ઓબ્જેક્ટમાં ફોર્મેટના આધારે સાચી પ્રોપર્ટીઝ હોય.

ટેમ્પ્લેટ લિટરલ અને કન્ડિશનલ ટાઇપ્સનું સંયોજન

જ્યારે તમે ટેમ્પ્લેટ લિટરલ ટાઇપ્સ અને કન્ડિશનલ ટાઇપ્સને જોડો છો ત્યારે વાસ્તવિક શક્તિ આવે છે. આ અતિ શક્તિશાળી ટાઇપ મેનીપ્યુલેશન માટે પરવાનગી આપે છે.

type EventName = `on${Capitalize}`;

type ExtractEventPayload = T extends EventName
  ? { type: T; payload: any }  // Simplified for demonstration
  : never;


type ClickEvent = EventName<"click">;  // "onClick"
type MouseOverEvent = EventName<"mouseOver">;  // "onMouseOver"


//Example function that takes a type
function processEvent(event: T): ExtractEventPayload {
    //In a real implementation, we would actually dispatch the event.
    console.log(`Processing event ${event}`);

    //In a real implementation, the payload would be based on event type.
    return { type: event, payload: {} } as ExtractEventPayload;
}

//Note that the return types are very specific:
const clickEvent = processEvent("onClick");  //  { type: "onClick"; payload: any; }
const mouseOverEvent = processEvent("onMouseOver"); //  { type: "onMouseOver"; payload: any; }

//If you use other strings, you get never:
// const someOtherEvent = processEvent("someOtherEvent"); // Type is `never`

શ્રેષ્ઠ પદ્ધતિઓ અને વિચારણાઓ

• તેને સરળ રાખો: શક્તિશાળી હોવા છતાં, આ એડવાન્સ્ડ ટાઇપ્સ ઝડપથી જટિલ બની શકે છે. સ્પષ્ટતા અને જાળવણીક્ષમતા માટે પ્રયત્ન કરો.
• સંપૂર્ણપણે પરીક્ષણ કરો: વ્યાપક યુનિટ પરીક્ષણો લખીને ખાતરી કરો કે તમારી ટાઇપ વ્યાખ્યાઓ અપેક્ષા મુજબ વર્તે છે.
• તમારા કોડનું દસ્તાવેજીકરણ કરો: કોડની વાંચનક્ષમતા સુધારવા માટે તમારા એડવાન્સ્ડ ટાઇપ્સના હેતુ અને વર્તનનું સ્પષ્ટપણે દસ્તાવેજીકરણ કરો.
• પ્રદર્શનને ધ્યાનમાં લો: એડવાન્સ્ડ ટાઇપ્સનો વધુ પડતો ઉપયોગ કમ્પાઇલેશન સમયને અસર કરી શકે છે. તમારા કોડનું પ્રોફાઇલ કરો અને જ્યાં જરૂરી હોય ત્યાં ઓપ્ટિમાઇઝ કરો.